GermanWikipedia - /page/entry.mu

Micron Document

<!DOCTYPE html>

<title>Multimethode</title>

</head>

<h1 id="firstHeading" class="firstHeading mw-first-heading">Multimethode</h1>

</header>

</div>

<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr">Als Multimethoden bezeichnet man <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a> einer <a href="Objektorientierte_Programmiersprache" class="mw-redirect" title="Objektorientierte Programmiersprache">objektorientierten Programmiersprache</a>, deren Auswahl nicht nur anhand des <a href="Datentyp" title="Datentyp">Typs</a> eines Objekts getroffen wird, sondern anhand der <a href="Dynamische_Bindung" title="Dynamische Bindung">dynamischen Typen</a> mehrerer Objekte. Diese Art der Methodenauswahl wird auch als multiple dispatch (‚mehrfache Verteilung‘) bezeichnet.

Ein ähnliches Konzept wie die mehrfache Verteilung ist das in vielen prozeduralen Programmiersprachen möglichen <a href="%C3%9Cberladen" title="Überladen">Überladen</a>, bei der Methoden <a href="Polymorphie_(Programmierung)" title="Polymorphie (Programmierung)">polymorph</a> bezüglich der statischen Typen ihrer Parameter sind. Der Unterschied ist, dass das Überladen bereits zur Übersetzungszeit stattfindet, die mehrfache Verteilung jedoch erst zur Laufzeit.

Während bei klassischen objektorientierten Sprachen wie <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a> ausschließlich der dynamische Typ des impliziten ersten Parameters <code>this</code> herangezogen wird, können in Sprachen mit multiple dispatch Methoden auch auf die dynamischen Typen aller ihrer <a href="Parameter_(Informatik)" title="Parameter (Informatik)">Parameter</a> spezialisiert werden. Die von vielen (insbesondere <a href="C_(Programmiersprache)" title="C (Programmiersprache)">C</a>-ähnlichen) kompilierten Sprachen angebotene Überladung entspricht einem multiple dispatch zur Übersetzungszeit. Interessanterweise bieten die meisten Skriptsprachen Multimethoden in Form von Überladung jedoch zu Gunsten <a href="Dynamische_Typisierung" title="Dynamische Typisierung">dynamischer Typisierung</a> nicht an. Allerdings schließt dynamische Typisierung Multimethoden nicht aus.

Die erste und bekannteste objektorientierte Umgebung, die diese Fähigkeit hat, ist das <a href="Common_Lisp_Object_System" title="Common Lisp Object System">Common Lisp Object System</a> (CLOS),<a href="#cite_note-1">[1]</a> aber auch Sprachen wie <a href="Dylan_(Programmiersprache)" title="Dylan (Programmiersprache)">Dylan</a>, <a href="Slate_(Programmiersprache)" title="Slate (Programmiersprache)">Slate</a>, Cecil, <a href="Guile" class="mw-redirect" title="Guile">Guile</a>, <a href="Seed7" title="Seed7">Seed7</a>, <a href="Julia_(Programmiersprache)" title="Julia (Programmiersprache)">Julia</a> oder der Java-Abkömmling <a href="Nice_(Programmiersprache)" title="Nice (Programmiersprache)">Nice</a> bieten Derartiges. In <a href="C%2B%2B" title="C++">C++</a> ist es möglich, Multimethoden als <a href="Funktionsobjekt" class="mw-redirect" title="Funktionsobjekt">Funktoren</a> und <a href="Template_(Programmierung)" class="mw-redirect" title="Template (Programmierung)">Templates</a> auf verschiedene Weisen zu implementieren. In der <a href="Java_Virtual_Machine" title="Java Virtual Machine">JVM</a> Welt ist z. B. <a href="Groovy" title="Groovy">Groovy</a> eine Java-Syntax-kompatible Sprache mit größerer Verbreitung, die (sowohl bei dynamischer als auch statischer Kompilierung) standardmäßig Multimethoden unterstützt.<a href="#cite_note-2">[2]</a>

<div class="mw-heading mw-heading2"><h2 id="Multimethoden_in_Common_Lisp">Multimethoden in Common Lisp</h2></div>

Die objektorientierte Programmierung mit Multimethoden unterscheidet sich in einigen Punkten grundlegend von eindimensionaler objektorientierter Programmierung. In Common Lisp basieren Multimethoden auf drei elementaren Konzepten, die anders zu verstehen sind als z. B. in Java:

<ul><li>Klassen: Sie werden immer ohne eigene Methoden definiert. Zur Klassendefinition gehört nur die Liste der Superklassen und die Liste ihrer Slots (= „Membervariablen“). Auch später können der Klassendefinition keinerlei Methoden hinzugefügt werden.</li>

<li>Generische Funktionen: Statt einer Klasse werden die Methoden unter einer generischen Funktion gleichen Namens zusammengefasst. Die generische Funktion ist selbst nur ein Container für die dazugehörigen Methoden.</li>

<li>Methoden: Sie kennen keinen impliziten <code>this</code>-Parameter im Sinne eines einzelnen, diese Methode aufrufenden Objekts, weil es sonst auch <code>this2</code>, <code>this3</code> usw. geben müsste. Stattdessen erscheinen alle angesprochenen Objekte wie normale Parameter in der Parameterliste der Methode.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Praktisches_Beispiel_in_Common_Lisp">Praktisches Beispiel in Common Lisp</h2></div>

Das folgende Beispiel verwendet Multimethoden, um die Bildung der Schnittmenge mit drei intern unterschiedlich dargestellten Mengen interoperabel zu implementieren.

<div class="mw-heading mw-heading3"><h3 id="Mengendarstellungen">Mengendarstellungen</h3></div>

Es sollen die folgenden drei Implementierungen für Mengen unterstützt werden:

<ol><li>Darstellung durch <a href="Extension_und_Intension#Intension" title="Extension und Intension">Intension</a>

<dl><dd>Hierbei ist die Elementzugehörigkeit durch ein <a href="Pr%C3%A4dikat_(Logik)" title="Prädikat (Logik)">Prädikat</a> gegeben:</dd>

</mrow>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle M:=\lbrace x|P(x)\rbrace }</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/db9738ed09a3a1d625d804aeade1af64e472fd8d.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:15.373ex; height:2.843ex;" alt="{\displaystyle M:=\lbrace x|P(x)\rbrace }" loading="lazy"></dd>

<dd>Alle Elemente <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle x}</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/87f9e315fd7e2ba406057a97300593c4802b53e4.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.33ex; height:1.676ex;" alt="{\displaystyle x}" loading="lazy">, für die <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle P(x)}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle P(x)}</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/89833156eff2c51bfb8750db3306a0544ce34e14.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:4.884ex; height:2.843ex;" alt="{\displaystyle P(x)}" loading="lazy"> wahr ist, gehören zu <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle M}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle M}</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/f82cade9898ced02fdd08712e5f0c0151758a0dd.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:2.442ex; height:2.176ex;" alt="{\displaystyle M}" loading="lazy">. Die Menge kann unendlich groß sein. Die Darstellung von <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle P}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle P}</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/b4dc73bf40314945ff376bd363916a738548d40a.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.745ex; height:2.176ex;" alt="{\displaystyle P}" loading="lazy"> erfolgt durch einen anonymen <a href="Lambda-Ausdruck" class="mw-redirect" title="Lambda-Ausdruck">Lambda-Ausdruck</a>.</dd></dl></li>

<li>Darstellung durch <a href="Extension_und_Intension#Extension" title="Extension und Intension">Extension</a>

<dl><dd>Bei dieser Darstellung werden alle Elemente der Menge aufgezählt:</dd>

</mrow>

<mtext>STOCK</mtext>

</mrow>

<mtext>REGENSCHIRM</mtext>

</mrow>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle M:=\lbrace 2,39,{\text{HUT}},{\text{STOCK}},{\text{REGENSCHIRM}}\rbrace }</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/7412aa301a6e35e55578693f332c787bee3ae101.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:47.403ex; height:2.843ex;" alt="{\displaystyle M:=\lbrace 2,39,{\text{HUT}},{\text{STOCK}},{\text{REGENSCHIRM}}\rbrace }" loading="lazy"></dd></dl></li>

<li>Darstellung als Intervall

<dl><dd>Ein zusammenhängendes Intervall aus der Menge <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \mathbb {Z} }">

</mrow>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle \mathbb {Z} }</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/449494a083e0a1fda2b61c62b2f09b6bee4633dc.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.55ex; height:2.176ex;" alt="{\displaystyle \mathbb {Z} }" loading="lazy"> bildet die Menge <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle M}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle M}</annotation>

</semantics>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle M:=\lbrace 10,\dotsc ,20\rbrace }</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/6125256bf96816216e25b10f404f10a7981e3625.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:18.34ex; height:2.843ex;" alt="{\displaystyle M:=\lbrace 10,\dotsc ,20\rbrace }" loading="lazy"></dd></dl></li></ol>

<div class="mw-heading mw-heading3"><h3 id="Programmcode">Programmcode</h3></div>

<div class="mw-heading mw-heading4"><h4 id="Klassendefinitionen">Klassendefinitionen</h4></div>

Für diese drei Darstellungen werden die Klassen <code>set-by-intension</code>, <code>set-by-extension</code> und <code>integer-range-set</code> definiert. Die beiden letzteren sind von der abstrakten Klasse <code>enumeratable-set</code> abgeleitet, die ihrerseits wie <code>set-by-intension</code> von der Hauptklasse <code>any-set</code> abgeleitet ist.

Die Beziehung der Klassen ist demnach wie folgt:

/* start https://de.wikipedia.org/ */

.mw-parser-output .stammbaum td{border-color:#000000!important}@media screen{html.skin-theme-clientpref-night .mw-parser-output .stammbaum td{border-color:#ffffff!important}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .stammbaum td{border-color:#ffffff!important}}

/* end https://de.wikipedia.org/ */

</style><table class="stammbaum" style="border-collapse:collapse; text-align:center;margin:1em;">

<tr style="font-weight:normal;"><td colspan="6" rowspan="2" style="border: 2px solid; padding: 0.2em; ;"><code>set-by-intension</code></td><td rowspan="2" colspan="2"><div style="width: 2em; height: 2em;"> </div></td><td rowspan="2" colspan="2"><div style="width: 2em; height: 2em;"> </div></td><td rowspan="2" colspan="2"><div style="width: 2em; height: 2em;"> </div></td><td colspan="6" rowspan="2" style="border: 2px solid; padding: 0.2em; ;"><code>enumerateable-set</code></td><td rowspan="2" colspan="2"><div style="width: 2em; height: 2em;"> </div></td><td rowspan="2" colspan="2"><div style="width: 2em; height: 2em;"> </div></td></tr>

</tbody></table>

Die Umsetzung der Klassenhierarchie in Common Lisp erfolgt in fünf einzelnen Definitionen.

<div class="mw-heading mw-heading5"><h5 id="Klasse_any-set_(abstrakt)">Klasse any-set (abstrakt)</h5></div>

Common Lisp: <code>(defclass …)</code>

Klassen werden in Common Lisp mit <code>(defclass <superclasses> <slot-definitions>)</code> deklariert. Dabei ist <superclasses> die Liste der Superklassen und <slot-definitions> eine Liste von Slotdefinitionen.

</div>

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass any-set ()

())

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Klasse_set-by-intension">Klasse set-by-intension</h5></div>

Diese enthält nur das einstellige Prädikat <code>predicate</code> als Funktion mit Wertebereich <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \lbrace w,f\rbrace }">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle \lbrace w,f\rbrace }</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/88f9bfb85fb1956a1ab0665557026b0474345fca.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:6.302ex; height:2.843ex;" alt="{\displaystyle \lbrace w,f\rbrace }" loading="lazy">, das entscheidet, ob das ihm übergebene Argument zu <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle M}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle M}</annotation>

</semantics>

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass set-by-intension (any-set)

((predicate :accessor predicate :initarg :predicate)))

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Klasse_enumerateable-set_(abstrakt)">Klasse enumerateable-set (abstrakt)</h5></div>

Ihr Zweck ist es, eine gemeinsame Elternklasse für die Klassen <code>set-by-extension</code> und <code>integer-range-set</code> als Bezugspunkt für Methodendefinitionen zur Verfügung zu haben.

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass enumerateable-set (any-set)

())

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Klasse_set-by-extension">Klasse set-by-extension</h5></div>

Common Lisp: Slot-Definitionen

Die Definition von Slots (in Java „Membervariablen“) enthält als erstes den Namen (z. B. <code>ext</code>) und meistens auch den gewünschten Namen der <a href="Zugriffsfunktion" title="Zugriffsfunktion">Zugriffsfunktion</a> (getter/setter), die in Lisp „Accessor“ heißt. Meistens wird auch noch der Name des Initialisierungsargumentes hinter dem Schlüsselwort <code>:initarg</code> angegeben, der bei der Instanziierung benutzt wird, um dem Slot einen initialen Wert zuzuweisen. Im Beispielprogramm sind der Slotname, der <code>:accessor</code> und das <code>:initarg</code> immer identisch.

</div>

Sie enthält nur den Slot <code>ext</code>, der eine Liste der Elemente enthält:

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass set-by-extension (enumerateable-set)

((ext :accessor ext :initarg :ext)))

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Klasse_integer-range-set">Klasse integer-range-set</h5></div>

Diese Form speichert von dem geschlossenen Ganzzahlenbereich den kleinsten Wert <code>from</code> und der größten Wert <code>to</code>.

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass integer-range-set (enumerateable-set)

((from :accessor from :initarg :from)

(to :accessor to :initarg :to)))

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Die_leere_Menge">Die leere Menge</h5></div>

Die leere Menge <code>empty-set</code> wird als konstante Instanz der Klasse <code>set-by-extension</code> ohne Elemente konstruiert. Die Instanziierung erfolgt in Common Lisp durch die Funktion <code>make-instance</code> unter Angabe der

Klasse und des Initialisierungsargumentes, das in obiger Klassendefinition <code>:ext</code> heißt. Für dieses Argument wird hier die leere Liste <code>nil</code> übergeben.

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defvar empty-set (make-instance 'set-by-extension :ext nil))

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Generische_Funktionen">Generische Funktionen</h4></div>

Nun erfolgt die Definition der <a href="Generische_Funktion" title="Generische Funktion">generischen Funktion</a> <code>enumeration</code> für die Klasse <code>enumerateable-set</code> sowie der generischen Funktion <code>intersection2</code> für zwei Argumente vom Typ <code>any-set</code>. Generische Funktionen legen nur die <a href="Signatur_(Programmierung)" title="Signatur (Programmierung)">Signatur</a> fest, sie definieren nur den Typ der Parameter, nicht die Parameternamen und sie haben keinen Funktionskörper. Die Definitionen kündigen die Existenz von (konkreten) Methoden für die genannten oder von ihnen abgeleitete Klassen an.

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defgeneric enumeration (enumerateable-set))

(defgeneric intersection2 (any-set any-set))

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Methoden_der_generischen_Funktion_enumeration">Methoden der generischen Funktion enumeration</h4></div>

Diese beiden Methoden sind noch keine Multimethoden. In Java würden sie einfach mit <code>Enumeration enumeration();</code> als Methoden einer Klasse <code>SetByExtension</code> deklariert werden. <code>enumeration</code> liefert eine Aufzählung der Elemente einer indirekten Instanz von <code>enumerateable-set</code>, also von direkten Instanzen von <code>set-by-extension</code> und <code>integer-range-set</code>.

(ext s))

(defmethod enumeration ((s integer-range-set))

(loop for i from (from s) to (to s) collect i))

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Konkrete_Methoden_der_generischen_Funktion_intersection2">Konkrete Methoden der generischen Funktion intersection2</h4></div>

Common-Lisp: Funktionen und Makros

<code>(remove-if-not …)</code>

Übernimmt eine Funktion und eine Liste. Die Funktion wird der Reihe nach auf jedes Element der Liste angewandt. Zurückgegeben wird eine neue Liste aller Elemente, für die die Funktion „wahr“ geliefert hat.

<hr>

<code>(intersection ...)</code>

Bildet eine Liste mit der Schnittmenge der Elemente aller übergebenen Listen. <code>(intersection '(1 2 3) '(2 3 4))</code> liefert z. B. <code>'(2 3)</code>.

<hr>

<code>(lambda …)</code>

Übernimmt eine Parameterliste und einen Ausdruck, in dem die in der Liste genannten Parameter vorkommen dürfen. Es liefert eine anonyme Funktion zurück, die mit einer passenden Argumentenliste gerufen werden kann und mit dieser den übergebenen Ausdruck berechnet.

</div>

Die fünf Methoden der generischen Funktion <code>intersection2</code> sind sämtlich Multimethoden.

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defmethod intersection2 ((a set-by-intension) (b enumerateable-set))

(make-instance 'set-by-extension

:ext (remove-if-not (predicate a)

(enumeration b))))

(defmethod intersection2 ((a set-by-intension) (b set-by-intension))

;; In diesem Fall wird aus den beiden Prädikaten von a und

;; b ein neues Prädikat durch UND-Verknüpfung zusammengesetzt und

;; die Ergebnis-Instanz der Klasse SET-BY-INTENSION damit

;; initialisiert:

(make-instance 'set-by-intension

:predicate (lambda (x)

(and (funcall (predicate a) x)

(funcall (predicate b) x)))))

(defmethod intersection2 ((a enumerateable-set) (b set-by-intension))

(intersection2 b a)) ; Rückführung auf den kommutativen Fall

(defmethod intersection2 ((a enumerateable-set) (b enumerateable-set))

(make-instance 'set-by-extension

:ext (intersection (enumeration a) (enumeration b))))

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Methode_der_generischen_Funktion_intersection2_für_Aufrufe_mit_zwei_Parametern_der_Klasse_integer-range-set">Methode der generischen Funktion intersection2 für Aufrufe mit zwei Parametern der Klasse integer-range-set</h5></div>

Obwohl dieser Fall schon durch die vierte Methode oben abgedeckt ist, bietet es sich hier an, eine spezifischere Methode vorzusehen um wieder ein Ergebnis der Klasse <code>integer-range-set</code> zu erhalten, da deren Darstellung kompakter ist.

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defmethod intersection2 ((a integer-range-set) (b integer-range-set))

;; Es wird das Maximum N der unteren und das Minimum M der

;; Obergrenzen gebildet. Falls nun N>M gilt, ist die Schnittmenge

;; leer, sonst eine Instanz der Klasse INTEGER-RANGE-SET mit den

;; Grenzen N und M

(let ((n (max (from a) (from b)))

(m (min (to a) (to b))))

(if (> n m)

empty-set

(make-instance 'integer-range-set :from n :to m))))

</pre></div>

<div class="mw-heading mw-heading5"><h5 id="Zusätzliche_Methoden_für_die_generische_Funktion_intersection2_für_den_Umgang_mit_der_leeren_Menge">Zusätzliche Methoden für die generische Funktion intersection2 für den Umgang mit der leeren Menge</h5></div>

Common-Lisp: Der <code>eql</code>-Specializer

Common Lisp kann Methoden einer generischen Funktion nicht nur auf Klassen spezialisieren, sondern auch auf eine einzelne Instanz. Dazu wird als Typ des Parameters nicht eine Klasse angegeben, sondern der Ausdruck <code>(eql <instanz>)</code>. Wenn die zugehörige generische Funktion nun mit genau dieser Instanz aufgerufen wird, dann ist diese Methode spezifischer als eine, die an der gleichen Position mit einer passenden Klasse definiert wurde und wird statt dieser aufgerufen.

</div>

Mit den folgenden beiden Methoden wird durch Verwendung eines <code>eql</code>-Specializers (siehe Box) erreicht, dass die Schnittmenge aus der leeren Menge und einer beliebigen Menge ohne weitere Untersuchung die leere Menge selbst ist:

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defmethod intersection2 ((a (eql empty-set)) (b any-set))

empty-set)

(defmethod intersection2 ((a any-set) (b (eql empty-set)))

empty-set)

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="print-object-Methoden">print-object-Methoden</h4></div>

Mit obigen Definitionen ist die Funktionalität vollständig umgesetzt. Um den Dialog mit Common Lisp zu vereinfachen, erfolgt nun noch die Definition von geeigneten Methoden für die durch das System vordefinierte Generische Funktion <code>print-object</code>, die das Lisp-System zur Darstellung der Mengen bei der Ausgabe heranzieht.

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defmethod print-object ((s set-by-extension) stream)

(prin1 (ext s) stream))

(defmethod print-object ((s set-by-intension) stream)

(format stream "~A" (function-lambda-expression (predicate s))))

(defmethod print-object ((s integer-range-set) stream)

(format stream "(~A .. ~A)" (from s) (to s)))

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Anwendungsbeispiel">Anwendungsbeispiel</h3></div>

Common-Lisp: <code>(loop … )</code>

Das Makro <code>loop</code> ist ein mächtiges Iterationsmittel. <code>loop</code>-Schleifen können zumeist ganz naiv gelesen werden, um ihren Inhalt zu erfassen. Das Beispiel links kann so übersetzt werden:

<ul><li>„n ist eine Primzahl, wenn für jede natürliche Zahl von 2 bis zur Wurzel aus n gilt, dass der Divisionsrest von n/i niemals 0 ist“</li></ul>

Davor ist noch die Bedingung <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle n>1}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle n>1}</annotation>

</semantics>

</math><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/ee74e1cc07e7041edf0fcbd4481f5cd32ad17b64.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:5.656ex; height:2.176ex;" alt="{\displaystyle n>1}" loading="lazy"> gesetzt, da die Zahl 1 im mathematischen Sinn keine Primzahl ist.

</div>

Die Gesamtfunktionalität ist aus folgendem Anwendungsbeispiel ersichtlich.

Die Menge aller Primzahlen kann durch das Prädikat <code>prime</code> dargestellt werden.

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defun prime (n)

(when (> n 1)

never (eql 0 (mod n i)))))

</pre></div>

Mit dieser Definition als Prädikat ist es jetzt möglich, die Menge aller Primzahlen <code>set-of-primes</code> als Instanz von <code>set-by-intension</code> zu konstruieren:

:predicate #'prime))

</pre></div>

Als zweite Menge fungiert die Menge <code>first-100</code> der ganzen Zahlen von 1 bis 100:

<div style="width:65%" class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(set 'first-100 (make-instance 'integer-range-set :from 1 :to 100))

</pre></div>

Die Schnittmenge beider Mengen, also die Primzahlen von 1 bis 100, kann dann jetzt durch den Aufruf der Generischen Funktion <code>intersection2</code> berechnet werden:

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(intersection2 set-of-primes first-100)

</pre></div>

Es erfolgt die korrekte Ausgabe

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97)

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Erläuterung">Erläuterung</h3></div>

<ul><li>Am Methodenaufruf ist keine einzelne aufrufende Instanz syntaktisch erkennbar, da alle Parameter gleich behandelt werden. Es gibt kein implizites <code>this</code>, oder ähnliches.</li>

<li>Methoden werden in Common Lisp nie direkt aufgerufen, sondern ausschließlich auf dem Umweg über die generische Funktion gleichen Namens.</li>

<li>Die generische Funktion führt den Dispatch auf „eingehängten“ Methoden durch. Dazu ermittelt sie zunächst eine nach Spezifität sortierte Liste der anwendbaren Methoden und ruft die Methode mit der höchsten Spezifität auf. Anwendbar sind dabei alle Methoden, deren formale Parameter entweder den Klassen der aktuellen Parameter entsprechen oder direkt oder indirekt deren Elternklasse sind.</li>

<li>Wird die Deklaration der generischen Funktion weggelassen, so erledigt Common Lisp das selbst, sobald die erste Methodendefinition erfolgt.</li>

<li>Die Vererbungsmechanismen innerhalb der Klassenhierarchie bezüglich der Slots („Membervariablen“) arbeiten wie bei eindimensionaler objektorientierter Programmierung.</li>

<li>In diesem Beispiel wird das Common Lisp Object System (CLOS) nur so weit vorgestellt, wie dies zum Verständnis von Multimethoden erforderlich ist. Der Funktionsumfang von CLOS geht erheblich weiter.</li>

<li>Multimethoden können die eindimensionale objektorientierte Programmierung vollständig darstellen, aber nicht umgekehrt.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>

/* start https://de.wikipedia.org/ */

.mw-parser-output .webarchiv-memento a{color:inherit}

/* end https://de.wikipedia.org/ */

</style><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090927003121/http://webstore.ansi.org/RecordDetail.aspx?sku=ANSI+INCITS+226-1994+(R2004)">Common Lisp Standard – ANSI INCITS 226-1994 (R2004)</a> (<a href="Webarchivierung#Begrifflichkeiten" title="Webarchivierung">Memento</a> vom 27. September 2009 im <a href="Internet_Archive" title="Internet Archive">Internet Archive</a>)</li>

<li>Patrick M. Krusenotto Funktionale Programmierung und Metaprogrammierung – Interaktiv in Common Lisp Springer 2016, ISBN 978-3-658-13743-4.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>

<ul><li><a rel="nofollow" class="external text" href="https://www.lispworks.com/documentation/HyperSpec/Front/index.htm">Common Lisp HyperSpec</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>

<li id="cite_note-1"><a href="#cite_ref-1">↑</a> <a rel="nofollow" class="external text" href="https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node260.html#SECTION003200000000000000000">Common Lisp – The Language.</a> 2nd Edition.

</li>

<li id="cite_note-2"><a href="#cite_ref-2">↑</a> <a rel="nofollow" class="external text" href="https://groovy-lang.org/differences.html">Groovy - Multi-methods</a>

</li>

</ol></div><div><div class="zim-footer">

Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-06-25" href="https://de.wikipedia.org/wiki/?title=Multimethode&oldid=257349726">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.

</div>

</div></div>

</div>

</main>

</div>

</body></html>